home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / gfx / show / mpeg2decodeWOS.lha / mpeg2decode / src / gethdr.c < prev    next >
C/C++ Source or Header  |  1999-02-23  |  30KB  |  1,081 lines
  1. /* gethdr.c, header decoding                                                */
  2.  
  3. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  4.  
  5. /*
  6.  * Disclaimer of Warranty
  7.  *
  8.  * These software programs are available to the user without any license fee or
  9.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10.  * any and all warranties, whether express, implied, or statuary, including any
  11.  * implied warranties or merchantability or of fitness for a particular
  12.  * purpose.  In no event shall the copyright-holder be liable for any
  13.  * incidental, punitive, or consequential damages of any kind whatsoever
  14.  * arising from the use of these programs.
  15.  *
  16.  * This disclaimer of warranty extends to the user of these programs and user's
  17.  * customers, employees, agents, transferees, successors, and assigns.
  18.  *
  19.  * The MPEG Software Simulation Group does not represent or warrant that the
  20.  * programs furnished hereunder are free of infringement of any third-party
  21.  * patents.
  22.  *
  23.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24.  * are subject to royalty fees to patent holders.  Many of these patents are
  25.  * general enough such that they are unavoidable regardless of implementation
  26.  * design.
  27.  *
  28.  */
  29.  
  30. #include <stdio.h>
  31.  
  32. #include "config.h"
  33. #include "global.h"
  34.  
  35. /* private prototypes */
  36. static void sequence_header _ANSI_ARGS_((void));
  37. static void group_of_pictures_header _ANSI_ARGS_((void));
  38. static void picture_header _ANSI_ARGS_((void));
  39. static void extension_and_user_data _ANSI_ARGS_((void));
  40. static void sequence_extension _ANSI_ARGS_((void));
  41. static void sequence_display_extension _ANSI_ARGS_((void));
  42. static void quant_matrix_extension _ANSI_ARGS_((void));
  43. static void sequence_scalable_extension _ANSI_ARGS_((void));
  44. static void picture_display_extension _ANSI_ARGS_((void));
  45. static void picture_coding_extension _ANSI_ARGS_((void));
  46. static void picture_spatial_scalable_extension _ANSI_ARGS_((void));
  47. static void picture_temporal_scalable_extension _ANSI_ARGS_((void));
  48. static int  extra_bit_information _ANSI_ARGS_((void));
  49. static void copyright_extension _ANSI_ARGS_((void));
  50. static void user_data _ANSI_ARGS_((void));
  51. static void user_data _ANSI_ARGS_((void));
  52.  
  53.  
  54.  
  55.  
  56. /* introduced in September 1995 to assist spatial scalable decoding */
  57. static void Update_Temporal_Reference_Tacking_Data _ANSI_ARGS_((void));
  58. /* private variables */
  59. static int Temporal_Reference_Base = 0;
  60. static int True_Framenum_max  = -1;
  61. static int Temporal_Reference_GOP_Reset = 0;
  62.  
  63. #define RESERVED    -1 
  64. static double frame_rate_Table[16] =
  65. {
  66.   0.0,
  67.   ((23.0*1000.0)/1001.0),
  68.   24.0,
  69.   25.0,
  70.   ((30.0*1000.0)/1001.0),
  71.   30.0,
  72.   50.0,
  73.   ((60.0*1000.0)/1001.0),
  74.   60.0,
  75.  
  76.   RESERVED,
  77.   RESERVED,
  78.   RESERVED,
  79.   RESERVED,
  80.   RESERVED,
  81.   RESERVED,
  82.   RESERVED
  83. };
  84.  
  85. /*
  86.  * decode headers from one input stream
  87.  * until an End of Sequence or picture start code
  88.  * is found
  89.  */
  90. int Get_Hdr()
  91. {
  92.   unsigned int code;
  93.  
  94.   for (;;)
  95.   {
  96.     /* look for next_start_code */
  97.     next_start_code();
  98.     code = Get_Bits32();
  99.   
  100.     switch (code)
  101.     {
  102.     case SEQUENCE_HEADER_CODE:
  103.       sequence_header();
  104.       break;
  105.     case GROUP_START_CODE:
  106.       group_of_pictures_header();
  107.       break;
  108.     case PICTURE_START_CODE:
  109.       picture_header();
  110.       return 1;
  111.       break;
  112.     case SEQUENCE_END_CODE:
  113.       return 0;
  114.       break;
  115.     default:
  116.       if (!Quiet_Flag)
  117.         fprintf(stderr,"Unexpected next_start_code %08x (ignored)\n",code);
  118.       break;
  119.     }
  120.   }
  121. }
  122.  
  123.  
  124. /* align to start of next next_start_code */
  125.  
  126. void next_start_code()
  127. {
  128.   /* byte align */
  129.   Flush_Buffer(ld->Incnt&7);
  130.   while (Show_Bits(24)!=0x01L)
  131.     Flush_Buffer(8);
  132. }
  133.  
  134.  
  135. /* decode sequence header */
  136.  
  137. static void sequence_header()
  138. {
  139.   int i;
  140.   int pos;
  141.  
  142.   pos = ld->Bitcnt;
  143.   horizontal_size             = Get_Bits(12);
  144.   vertical_size               = Get_Bits(12);
  145.   aspect_ratio_information    = Get_Bits(4);
  146.   frame_rate_code             = Get_Bits(4);
  147.   bit_rate_value              = Get_Bits(18);
  148.   marker_bit("sequence_header()");
  149.   vbv_buffer_size             = Get_Bits(10);
  150.   constrained_parameters_flag = Get_Bits(1);
  151.  
  152.   if((ld->load_intra_quantizer_matrix = Get_Bits(1)))
  153.   {
  154.     for (i=0; i<64; i++)
  155.       ld->intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  156.   }
  157.   else
  158.   {
  159.     for (i=0; i<64; i++)
  160.       ld->intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  161.   }
  162.  
  163.   if((ld->load_non_intra_quantizer_matrix = Get_Bits(1)))
  164.   {
  165.     for (i=0; i<64; i++)
  166.       ld->non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  167.   }
  168.   else
  169.   {
  170.     for (i=0; i<64; i++)
  171.       ld->non_intra_quantizer_matrix[i] = 16;
  172.   }
  173.  
  174.   /* copy luminance to chrominance matrices */
  175.   for (i=0; i<64; i++)
  176.   {
  177.     ld->chroma_intra_quantizer_matrix[i] =
  178.       ld->intra_quantizer_matrix[i];
  179.  
  180.     ld->chroma_non_intra_quantizer_matrix[i] =
  181.       ld->non_intra_quantizer_matrix[i];
  182.   }
  183.  
  184. #ifdef VERBOSE
  185.   if (Verbose_Flag > NO_LAYER)
  186.   {
  187.     printf("sequence header (byte %d)\n",(pos>>3)-4);
  188.     if (Verbose_Flag > SEQUENCE_LAYER)
  189.     {
  190.       printf("  horizontal_size=%d\n",horizontal_size);
  191.       printf("  vertical_size=%d\n",vertical_size);
  192.       printf("  aspect_ratio_information=%d\n",aspect_ratio_information);
  193.       printf("  frame_rate_code=%d",frame_rate_code);
  194.       printf("  bit_rate_value=%d\n",bit_rate_value);
  195.       printf("  vbv_buffer_size=%d\n",vbv_buffer_size);
  196.       printf("  constrained_parameters_flag=%d\n",constrained_parameters_flag);
  197.       printf("  load_intra_quantizer_matrix=%d\n",ld->load_intra_quantizer_matrix);
  198.       printf("  load_non_intra_quantizer_matrix=%d\n",ld->load_non_intra_quantizer_matrix);
  199.     }
  200.   }
  201. #endif /* VERBOSE */
  202.  
  203. #ifdef VERIFY
  204.   verify_sequence_header++;
  205. #endif /* VERIFY */
  206.  
  207.   extension_and_user_data();
  208. }
  209.  
  210.  
  211.  
  212. /* decode group of pictures header */
  213. /* ISO/IEC 13818-2 section 6.2.2.6 */
  214. static void group_of_pictures_header()
  215. {
  216.   int pos;
  217.  
  218.   if (ld == &base)
  219.   {
  220.     Temporal_Reference_Base = True_Framenum_max + 1;    /* *CH* */
  221.     Temporal_Reference_GOP_Reset = 1;
  222.   }
  223.   pos = ld->Bitcnt;
  224.   drop_flag   = Get_Bits(1);
  225.   hour        = Get_Bits(5);
  226.   minute      = Get_Bits(6);
  227.   marker_bit("group_of_pictures_header()");
  228.   sec         = Get_Bits(6);
  229.   frame       = Get_Bits(6);
  230.   closed_gop  = Get_Bits(1);
  231.   broken_link = Get_Bits(1);
  232.  
  233. #ifdef VERBOSE
  234.   if (Verbose_Flag > NO_LAYER)
  235.   {
  236.     printf("group of pictures (byte %d)\n",(pos>>3)-4);
  237.     if (Verbose_Flag > SEQUENCE_LAYER)
  238.     {
  239.       printf("  drop_flag=%d\n",drop_flag);
  240.       printf("  timecode %d:%02d:%02d:%02d\n",hour,minute,sec,frame);
  241.       printf("  closed_gop=%d\n",closed_gop);
  242.       printf("  broken_link=%d\n",broken_link);
  243.     }
  244.   }
  245. #endif /* VERBOSE */
  246.  
  247. #ifdef VERIFY
  248.   verify_group_of_pictures_header++;
  249. #endif /* VERIFY */
  250.  
  251.   extension_and_user_data();
  252.  
  253. }
  254.  
  255.  
  256. /* decode picture header */
  257.  
  258. /* ISO/IEC 13818-2 section 6.2.3 */
  259. static void picture_header()
  260. {
  261.   int pos;
  262.   int Extra_Information_Byte_Count;
  263.  
  264.   /* unless later overwritten by picture_spatial_scalable_extension() */
  265.   ld->pict_scal = 0; 
  266.   
  267.   pos = ld->Bitcnt;
  268.   temporal_reference  = Get_Bits(10);
  269.   picture_coding_type = Get_Bits(3);
  270.   vbv_delay           = Get_Bits(16);
  271.  
  272.   if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
  273.   {
  274.     full_pel_forward_vector = Get_Bits(1);
  275.     forward_f_code = Get_Bits(3);
  276.   }
  277.   if (picture_coding_type==B_TYPE)
  278.   {
  279.     full_pel_backward_vector = Get_Bits(1);
  280.     backward_f_code = Get_Bits(3);
  281.   }
  282.  
  283. #ifdef VERBOSE
  284.   if (Verbose_Flag>NO_LAYER)
  285.   {
  286.     printf("picture header (byte %d)\n",(pos>>3)-4);
  287.     if (Verbose_Flag>SEQUENCE_LAYER)
  288.     {
  289.       printf("  temporal_reference=%d\n",temporal_reference);
  290.       printf("  picture_coding_type=%d\n",picture_coding_type);
  291.       printf("  vbv_delay=%d\n",vbv_delay);
  292.       if (picture_coding_type==P_TYPE || picture_coding_type==B_TYPE)
  293.       {
  294.         printf("  full_pel_forward_vector=%d\n",full_pel_forward_vector);
  295.         printf("  forward_f_code =%d\n",forward_f_code);
  296.       }
  297.       if (picture_coding_type==B_TYPE)
  298.       {
  299.         printf("  full_pel_backward_vector=%d\n",full_pel_backward_vector);
  300.         printf("  backward_f_code =%d\n",backward_f_code);
  301.       }
  302.     }
  303.   }
  304. #endif /* VERBOSE */
  305.  
  306. #ifdef VERIFY
  307.   verify_picture_header++;
  308. #endif /* VERIFY */
  309.  
  310.   Extra_Information_Byte_Count = 
  311.     extra_bit_information();
  312.   
  313.   extension_and_user_data();
  314.  
  315.   /* update tracking information used to assist spatial scalability */
  316.   Update_Temporal_Reference_Tacking_Data();
  317. }
  318.  
  319. /* decode slice header */
  320.  
  321. /* ISO/IEC 13818-2 section 6.2.4 */
  322. int slice_header()
  323. {
  324.   int slice_vertical_position_extension;
  325.   int quantizer_scale_code;
  326.   int pos;
  327.   int slice_picture_id_enable = 0;
  328.   int slice_picture_id = 0;
  329.   int extra_information_slice = 0;
  330.  
  331.   pos = ld->Bitcnt;
  332.  
  333.   slice_vertical_position_extension =
  334.     (ld->MPEG2_Flag && vertical_size>2800) ? Get_Bits(3) : 0;
  335.  
  336.   if (ld->scalable_mode==SC_DP)
  337.     ld->priority_breakpoint = Get_Bits(7);
  338.  
  339.   quantizer_scale_code = Get_Bits(5);
  340.   ld->quantizer_scale =
  341.     ld->MPEG2_Flag ? (ld->q_scale_type ? Non_Linear_quantizer_scale[quantizer_scale_code] : quantizer_scale_code<<1) : quantizer_scale_code;
  342.  
  343.   /* slice_id introduced in March 1995 as part of the video corridendum
  344.      (after the IS was drafted in November 1994) */
  345.   if (Get_Bits(1))
  346.   {
  347.     ld->intra_slice = Get_Bits(1);
  348.  
  349.     slice_picture_id_enable = Get_Bits(1);
  350.     slice_picture_id = Get_Bits(6);
  351.  
  352.     extra_information_slice = extra_bit_information();
  353.   }
  354.   else
  355.     ld->intra_slice = 0;
  356.  
  357. #ifdef VERBOSE
  358.   if (Verbose_Flag>PICTURE_LAYER)
  359.   {
  360.     printf("slice header (byte %d)\n",(pos>>3)-4);
  361.     if (Verbose_Flag>SLICE_LAYER)
  362.     {
  363.       if (ld->MPEG2_Flag && vertical_size>2800)
  364.         printf("  slice_vertical_position_extension=%d\n",slice_vertical_position_extension);
  365.   
  366.       if (ld->scalable_mode==SC_DP)
  367.         printf("  priority_breakpoint=%d\n",ld->priority_breakpoint);
  368.  
  369.       printf("  quantizer_scale_code=%d\n",quantizer_scale_code);
  370.  
  371.       printf("  slice_picture_id_enable = %d\n", slice_picture_id_enable);
  372.  
  373.       if(slice_picture_id_enable)
  374.         printf("  slice_picture_id = %d\n", slice_picture_id);
  375.  
  376.     }
  377.   }
  378. #endif /* VERBOSE */
  379.  
  380. #ifdef VERIFY
  381.   verify_slice_header++;
  382. #endif /* VERIFY */
  383.  
  384.  
  385.   return slice_vertical_position_extension;
  386. }
  387.  
  388.  
  389. /* decode extension and user data */
  390. /* ISO/IEC 13818-2 section 6.2.2.2 */
  391. static void extension_and_user_data()
  392. {
  393.   int code,ext_ID;
  394.  
  395.   next_start_code();
  396.  
  397.   while ((code = Show_Bits(32))==EXTENSION_START_CODE || code==USER_DATA_START_CODE)
  398.   {
  399.     if (code==EXTENSION_START_CODE)
  400.     {
  401.       Flush_Buffer32();
  402.       ext_ID = Get_Bits(4);
  403.       switch (ext_ID)
  404.       {
  405.       case SEQUENCE_EXTENSION_ID:
  406.         sequence_extension();
  407.         break;
  408.       case SEQUENCE_DISPLAY_EXTENSION_ID:
  409.         sequence_display_extension();
  410.         break;
  411.       case QUANT_MATRIX_EXTENSION_ID:
  412.         quant_matrix_extension();
  413.         break;
  414.       case SEQUENCE_SCALABLE_EXTENSION_ID:
  415.         sequence_scalable_extension();
  416.         break;
  417.       case PICTURE_DISPLAY_EXTENSION_ID:
  418.         picture_display_extension();
  419.         break;
  420.       case PICTURE_CODING_EXTENSION_ID:
  421.         picture_coding_extension();
  422.         break;
  423.       case PICTURE_SPATIAL_SCALABLE_EXTENSION_ID:
  424.         picture_spatial_scalable_extension();
  425.         break;
  426.       case PICTURE_TEMPORAL_SCALABLE_EXTENSION_ID:
  427.         picture_temporal_scalable_extension();
  428.         break;
  429.       case COPYRIGHT_EXTENSION_ID:
  430.         copyright_extension();
  431.         break;
  432.      default:
  433.         fprintf(stderr,"reserved extension start code ID %d\n",ext_ID);
  434.         break;
  435.       }
  436.       next_start_code();
  437.     }
  438.     else
  439.     {
  440. #ifdef VERBOSE
  441.       if (Verbose_Flag>NO_LAYER)
  442.         printf("user data\n");
  443. #endif /* VERBOSE */
  444.       Flush_Buffer32();
  445.       user_data();
  446.     }
  447.   }
  448. }
  449.  
  450.  
  451. /* decode sequence extension */
  452.  
  453. /* ISO/IEC 13818-2 section 6.2.2.3 */
  454. static void sequence_extension()
  455. {
  456.   int horizontal_size_extension;
  457.   int vertical_size_extension;
  458.   int bit_rate_extension;
  459.   int vbv_buffer_size_extension;
  460.   int pos;
  461.  
  462.   /* derive bit position for trace */
  463. #ifdef VERBOSE
  464.   pos = ld->Bitcnt;
  465. #endif
  466.  
  467.   ld->MPEG2_Flag = 1;
  468.  
  469.   ld->scalable_mode = SC_NONE; /* unless overwritten by sequence_scalable_extension() */
  470.   layer_id = 0;                /* unless overwritten by sequence_scalable_extension() */
  471.   
  472.   profile_and_level_indication = Get_Bits(8);
  473.   progressive_sequence         = Get_Bits(1);
  474.   chroma_format                = Get_Bits(2);
  475.   horizontal_size_extension    = Get_Bits(2);
  476.   vertical_size_extension      = Get_Bits(2);
  477.   bit_rate_extension           = Get_Bits(12);
  478.   marker_bit("sequence_extension");
  479.   vbv_buffer_size_extension    = Get_Bits(8);
  480.   low_delay                    = Get_Bits(1);
  481.   frame_rate_extension_n       = Get_Bits(2);
  482.   frame_rate_extension_d       = Get_Bits(5);
  483.  
  484.   frame_rate = frame_rate_Table[frame_rate_code] *
  485.     ((frame_rate_extension_n+1)/(frame_rate_extension_d+1));
  486.  
  487.   /* special case for 422 profile & level must be made */
  488.   if((profile_and_level_indication>>7) & 1)
  489.   {  /* escape bit of profile_and_level_indication set */
  490.   
  491.     /* 4:2:2 Profile @ Main Level */
  492.     if((profile_and_level_indication&15)==5)
  493.     {
  494.       profile = PROFILE_422;
  495.       level   = MAIN_LEVEL;  
  496.     }
  497.   }
  498.   else
  499.   {
  500.     profile = profile_and_level_indication >> 4;  /* Profile is upper nibble */
  501.     level   = profile_and_level_indication & 0xF;  /* Level is lower nibble */
  502.   }
  503.   
  504.  
  505.   horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  506.   vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);
  507.  
  508.  
  509.   /* ISO/IEC 13818-2 does not define bit_rate_value to be composed of
  510.    * both the original bit_rate_value parsed in sequence_header() and
  511.    * the optional bit_rate_extension in sequence_extension_header(). 
  512.    * However, we use it for bitstream verification purposes. 
  513.    */
  514.  
  515.   bit_rate_value += (bit_rate_extension << 18);
  516.   bit_rate = ((double) bit_rate_value) * 400.0;
  517.   vbv_buffer_size += (vbv_buffer_size_extension << 10);
  518.  
  519. #ifdef VERBOSE
  520.   if (Verbose_Flag>NO_LAYER)
  521.   {
  522.     printf("sequence extension (byte %d)\n",(pos>>3)-4);
  523.  
  524.     if (Verbose_Flag>SEQUENCE_LAYER)
  525.     {
  526.       printf("  profile_and_level_indication=%d\n",profile_and_level_indication);
  527.  
  528.       if (profile_and_level_indication<128)
  529.       {
  530.         printf("    profile=%d, level=%d\n",profile,level);
  531.       }
  532.  
  533.       printf("  progressive_sequence=%d\n",progressive_sequence);
  534.       printf("  chroma_format=%d\n",chroma_format);
  535.       printf("  horizontal_size_extension=%d\n",horizontal_size_extension);
  536.       printf("  vertical_size_extension=%d\n",vertical_size_extension);
  537.       printf("  bit_rate_extension=%d\n",bit_rate_extension);
  538.       printf("  vbv_buffer_size_extension=%d\n",vbv_buffer_size_extension);
  539.       printf("  low_delay=%d\n",low_delay);
  540.       printf("  frame_rate_extension_n=%d\n",frame_rate_extension_n);
  541.       printf("  frame_rate_extension_d=%d\n",frame_rate_extension_d);
  542.     }
  543.   }
  544. #endif /* VERBOSE */
  545.  
  546. #ifdef VERIFY
  547.   verify_sequence_extension++;
  548. #endif /* VERIFY */
  549.  
  550.  
  551. }
  552.  
  553.  
  554. /* decode sequence display extension */
  555.  
  556. static void sequence_display_extension()
  557. {
  558.   int pos;
  559.  
  560.   pos = ld->Bitcnt;
  561.   video_format      = Get_Bits(3);
  562.   color_description = Get_Bits(1);
  563.  
  564.   if (color_description)
  565.   {
  566.     color_primaries          = Get_Bits(8);
  567.     transfer_characteristics = Get_Bits(8);
  568.     matrix_coefficients      = Get_Bits(8);
  569.   }
  570.  
  571.   display_horizontal_size = Get_Bits(14);
  572.   marker_bit("sequence_display_extension");
  573.   display_vertical_size   = Get_Bits(14);
  574.  
  575. #ifdef VERBOSE
  576.   if (Verbose_Flag>NO_LAYER)
  577.   {
  578.     printf("sequence display extension (byte %d)\n",(pos>>3)-4);
  579.     if (Verbose_Flag>SEQUENCE_LAYER)
  580.     {
  581.  
  582.       printf("  video_format=%d\n",video_format);
  583.       printf("  color_description=%d\n",color_description);
  584.  
  585.       if (color_description)
  586.       {
  587.         printf("    color_primaries=%d\n",color_primaries);
  588.         printf("    transfer_characteristics=%d\n",transfer_characteristics);
  589.         printf("    matrix_coefficients=%d\n",matrix_coefficients);
  590.       }
  591.       printf("  display_horizontal_size=%d\n",display_horizontal_size);
  592.       printf("  display_vertical_size=%d\n",display_vertical_size);
  593.     }
  594.   }
  595. #endif /* VERBOSE */
  596.  
  597. #ifdef VERIFY
  598.   verify_sequence_display_extension++;
  599. #endif /* VERIFY */
  600.  
  601. }
  602.  
  603.  
  604. /* decode quant matrix entension */
  605. /* ISO/IEC 13818-2 section 6.2.3.2 */
  606. static void quant_matrix_extension()
  607. {
  608.   int i;
  609.   int pos;
  610.  
  611.   pos = ld->Bitcnt;
  612.  
  613.   if((ld->load_intra_quantizer_matrix = Get_Bits(1)))
  614.   {
  615.     for (i=0; i<64; i++)
  616.     {
  617.       ld->chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  618.       = ld->intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  619.       = Get_Bits(8);
  620.     }
  621.   }
  622.  
  623.   if((ld->load_non_intra_quantizer_matrix = Get_Bits(1)))
  624.   {
  625.     for (i=0; i<64; i++)
  626.     {
  627.       ld->chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  628.       = ld->non_intra_quantizer_matrix[scan[ZIG_ZAG][i]]
  629.       = Get_Bits(8);
  630.     }
  631.   }
  632.  
  633.   if((ld->load_chroma_intra_quantizer_matrix = Get_Bits(1)))
  634.   {
  635.     for (i=0; i<64; i++)
  636.       ld->chroma_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  637.   }
  638.  
  639.   if((ld->load_chroma_non_intra_quantizer_matrix = Get_Bits(1)))
  640.   {
  641.     for (i=0; i<64; i++)
  642.       ld->chroma_non_intra_quantizer_matrix[scan[ZIG_ZAG][i]] = Get_Bits(8);
  643.   }
  644.  
  645. #ifdef VERBOSE
  646.   if (Verbose_Flag>NO_LAYER)
  647.   {
  648.     printf("quant matrix extension (byte %d)\n",(pos>>3)-4);
  649.     printf("  load_intra_quantizer_matrix=%d\n",
  650.       ld->load_intra_quantizer_matrix);
  651.     printf("  load_non_intra_quantizer_matrix=%d\n",
  652.       ld->load_non_intra_quantizer_matrix);
  653.     printf("  load_chroma_intra_quantizer_matrix=%d\n",
  654.       ld->load_chroma_intra_quantizer_matrix);
  655.     printf("  load_chroma_non_intra_quantizer_matrix=%d\n",
  656.       ld->load_chroma_non_intra_quantizer_matrix);
  657.   }
  658. #endif /* VERBOSE */
  659.  
  660. #ifdef VERIFY
  661.   verify_quant_matrix_extension++;
  662. #endif /* VERIFY */
  663.  
  664. }
  665.  
  666.  
  667. /* decode sequence scalable extension */
  668. /* ISO/IEC 13818-2   section 6.2.2.5 */
  669. static void sequence_scalable_extension()
  670. {
  671.   int pos;
  672.  
  673.   pos = ld->Bitcnt;
  674.  
  675.   /* values (without the +1 offset) of scalable_mode are defined in 
  676.      Table 6-10 of ISO/IEC 13818-2 */
  677.   ld->scalable_mode = Get_Bits(2) + 1; /* add 1 to make SC_DP != SC_NONE */
  678.  
  679.   layer_id = Get_Bits(4);
  680.  
  681.   if (ld->scalable_mode==SC_SPAT)
  682.   {
  683.     lower_layer_prediction_horizontal_size = Get_Bits(14);
  684.     marker_bit("sequence_scalable_extension()");
  685.     lower_layer_prediction_vertical_size   = Get_Bits(14); 
  686.     horizontal_subsampling_factor_m        = Get_Bits(5);
  687.     horizontal_subsampling_factor_n        = Get_Bits(5);
  688.     vertical_subsampling_factor_m          = Get_Bits(5);
  689.     vertical_subsampling_factor_n          = Get_Bits(5);
  690.   }
  691.  
  692.   if (ld->scalable_mode==SC_TEMP)
  693.     Error("temporal scalability not implemented\n");
  694.  
  695. #ifdef VERBOSE
  696.   if (Verbose_Flag>NO_LAYER)
  697.   {
  698.     printf("sequence scalable extension (byte %d)\n",(pos>>3)-4);
  699.     if (Verbose_Flag>SEQUENCE_LAYER)
  700.     {
  701.       printf("  scalable_mode=%d\n",ld->scalable_mode-1);
  702.       printf("  layer_id=%d\n",layer_id);
  703.       if (ld->scalable_mode==SC_SPAT)
  704.       {
  705.         printf("    lower_layer_prediction_horiontal_size=%d\n",
  706.           lower_layer_prediction_horizontal_size);
  707.         printf("    lower_layer_prediction_vertical_size=%d\n",
  708.           lower_layer_prediction_vertical_size);
  709.         printf("    horizontal_subsampling_factor_m=%d\n",
  710.           horizontal_subsampling_factor_m);
  711.         printf("    horizontal_subsampling_factor_n=%d\n",
  712.           horizontal_subsampling_factor_n);
  713.         printf("    vertical_subsampling_factor_m=%d\n",
  714.           vertical_subsampling_factor_m);
  715.         printf("    vertical_subsampling_factor_n=%d\n",
  716.           vertical_subsampling_factor_n);
  717.       }
  718.     }
  719.   }
  720. #endif /* VERBOSE */
  721.  
  722. #ifdef VERIFY
  723.   verify_sequence_scalable_extension++;
  724. #endif /* VERIFY */
  725.  
  726. }
  727.  
  728.  
  729. /* decode picture display extension */
  730. /* ISO/IEC 13818-2 section 6.2.3.3. */
  731. static void picture_display_extension()
  732. {
  733.   int i;
  734.   int number_of_frame_center_offsets;
  735.   int pos;
  736.  
  737.   pos = ld->Bitcnt;
  738.   /* based on ISO/IEC 13818-2 section 6.3.12 
  739.     (November 1994) Picture display extensions */
  740.  
  741.   /* derive number_of_frame_center_offsets */
  742.   if(progressive_sequence)
  743.   {
  744.     if(repeat_first_field)
  745.     {
  746.       if(top_field_first)
  747.         number_of_frame_center_offsets = 3;
  748.       else
  749.         number_of_frame_center_offsets = 2;
  750.     }
  751.     else
  752.     {
  753.       number_of_frame_center_offsets = 1;
  754.     }
  755.   }
  756.   else
  757.   {
  758.     if(picture_structure!=FRAME_PICTURE)
  759.     {
  760.       number_of_frame_center_offsets = 1;
  761.     }
  762.     else
  763.     {
  764.       if(repeat_first_field)
  765.         number_of_frame_center_offsets = 3;
  766.       else
  767.         number_of_frame_center_offsets = 2;
  768.     }
  769.   }
  770.  
  771.  
  772.   /* now parse */
  773.   for (i=0; i<number_of_frame_center_offsets; i++)
  774.   {
  775.     frame_center_horizontal_offset[i] = Get_Bits(16);
  776.     marker_bit("picture_display_extension, first marker bit");
  777.     
  778.     frame_center_vertical_offset[i]   = Get_Bits(16);
  779.     marker_bit("picture_display_extension, second marker bit");
  780.   }
  781.  
  782. #ifdef VERBOSE
  783.   if (Verbose_Flag>NO_LAYER)
  784.   {
  785.     printf("picture display extension (byte %d)\n",(pos>>3)-4);
  786.     if (Verbose_Flag>SEQUENCE_LAYER)
  787.     {
  788.  
  789.       for (i=0; i<number_of_frame_center_offsets; i++)
  790.       {
  791.         printf("  frame_center_horizontal_offset[%d]=%d\n",i,
  792.           frame_center_horizontal_offset[i]);
  793.         printf("  frame_center_vertical_offset[%d]=%d\n",i,
  794.           frame_center_vertical_offset[i]);
  795.       }
  796.     }
  797.   }
  798. #endif /* VERBOSE */
  799.  
  800. #ifdef VERIFY
  801.   verify_picture_display_extension++;
  802. #endif /* VERIFY */
  803.  
  804. }
  805.  
  806.  
  807. /* decode picture coding extension */
  808. static void picture_coding_extension()
  809. {
  810.   int pos;
  811.  
  812.   pos = ld->Bitcnt;
  813.  
  814.   f_code[0][0] = Get_Bits(4);
  815.   f_code[0][1] = Get_Bits(4);
  816.   f_code[1][0] = Get_Bits(4);
  817.   f_code[1][1] = Get_Bits(4);
  818.  
  819.   intra_dc_precision         = Get_Bits(2);
  820.   picture_structure          = Get_Bits(2);
  821.   top_field_first            = Get_Bits(1);
  822.   frame_pred_frame_dct       = Get_Bits(1);
  823.   concealment_motion_vectors = Get_Bits(1);
  824.   ld->q_scale_type           = Get_Bits(1);
  825.   intra_vlc_format           = Get_Bits(1);
  826.   ld->alternate_scan         = Get_Bits(1);
  827.   repeat_first_field         = Get_Bits(1);
  828.   chroma_420_type            = Get_Bits(1);
  829.   progressive_frame          = Get_Bits(1);
  830.   composite_display_flag     = Get_Bits(1);
  831.  
  832.   if (composite_display_flag)
  833.   {
  834.     v_axis            = Get_Bits(1);
  835.     field_sequence    = Get_Bits(3);
  836.     sub_carrier       = Get_Bits(1);
  837.     burst_amplitude   = Get_Bits(7);
  838.     sub_carrier_phase = Get_Bits(8);
  839.   }
  840.  
  841. #ifdef VERBOSE
  842.   if (Verbose_Flag>NO_LAYER)
  843.   {
  844.     printf("picture coding extension (byte %d)\n",(pos>>3)-4);
  845.     if (Verbose_Flag>SEQUENCE_LAYER)
  846.     {
  847.       printf("  forward horizontal f_code=%d\n", f_code[0][0]);
  848.       printf("  forward vertical f_code=%d\n", f_code[0][1]);
  849.       printf("  backward horizontal f_code=%d\n", f_code[1][0]);
  850.       printf("  backward_vertical f_code=%d\n", f_code[1][1]);
  851.       printf("  intra_dc_precision=%d\n",intra_dc_precision);
  852.       printf("  picture_structure=%d\n",picture_structure);
  853.       printf("  top_field_first=%d\n",top_field_first);
  854.       printf("  frame_pred_frame_dct=%d\n",frame_pred_frame_dct);
  855.       printf("  concealment_motion_vectors=%d\n",concealment_motion_vectors);
  856.       printf("  q_scale_type=%d\n",ld->q_scale_type);
  857.       printf("  intra_vlc_format=%d\n",intra_vlc_format);
  858.       printf("  alternate_scan=%d\n",ld->alternate_scan);
  859.       printf("  repeat_first_field=%d\n",repeat_first_field);
  860.       printf("  chroma_420_type=%d\n",chroma_420_type);
  861.       printf("  progressive_frame=%d\n",progressive_frame);
  862.       printf("  composite_display_flag=%d\n",composite_display_flag);
  863.  
  864.       if (composite_display_flag)
  865.       {
  866.         printf("    v_axis=%d\n",v_axis);
  867.         printf("    field_sequence=%d\n",field_sequence);
  868.         printf("    sub_carrier=%d\n",sub_carrier);
  869.         printf("    burst_amplitude=%d\n",burst_amplitude);
  870.         printf("    sub_carrier_phase=%d\n",sub_carrier_phase);
  871.       }
  872.     }
  873.   }
  874. #endif /* VERBOSE */
  875.  
  876. #ifdef VERIFY
  877.   verify_picture_coding_extension++;
  878. #endif /* VERIFY */
  879. }
  880.  
  881.  
  882. /* decode picture spatial scalable extension */
  883. /* ISO/IEC 13818-2 section 6.2.3.5. */
  884. static void picture_spatial_scalable_extension()
  885. {
  886.   int pos;
  887.  
  888.   pos = ld->Bitcnt;
  889.  
  890.   ld->pict_scal = 1; /* use spatial scalability in this picture */
  891.  
  892.   lower_layer_temporal_reference = Get_Bits(10);
  893.   marker_bit("picture_spatial_scalable_extension(), first marker bit");
  894.   lower_layer_horizontal_offset = Get_Bits(15);
  895.   if (lower_layer_horizontal_offset>=16384)
  896.     lower_layer_horizontal_offset-= 32768;
  897.   marker_bit("picture_spatial_scalable_extension(), second marker bit");
  898.   lower_layer_vertical_offset = Get_Bits(15);
  899.   if (lower_layer_vertical_offset>=16384)
  900.     lower_layer_vertical_offset-= 32768;
  901.   spatial_temporal_weight_code_table_index = Get_Bits(2);
  902.   lower_layer_progressive_frame = Get_Bits(1);
  903.   lower_layer_deinterlaced_field_select = Get_Bits(1);
  904.  
  905. #ifdef VERBOSE
  906.   if (Verbose_Flag>NO_LAYER)
  907.   {
  908.     printf("picture spatial scalable extension (byte %d)\n",(pos>>3)-4);
  909.     if (Verbose_Flag>SEQUENCE_LAYER)
  910.     {
  911.       printf("  lower_layer_temporal_reference=%d\n",lower_layer_temporal_reference);
  912.       printf("  lower_layer_horizontal_offset=%d\n",lower_layer_horizontal_offset);
  913.       printf("  lower_layer_vertical_offset=%d\n",lower_layer_vertical_offset);
  914.       printf("  spatial_temporal_weight_code_table_index=%d\n",
  915.         spatial_temporal_weight_code_table_index);
  916.       printf("  lower_layer_progressive_frame=%d\n",lower_layer_progressive_frame);
  917.       printf("  lower_layer_deinterlaced_field_select=%d\n",lower_layer_deinterlaced_field_select);
  918.     }
  919.   }
  920. #endif /* VERBOSE */
  921.  
  922. #ifdef VERIFY
  923.   verify_picture_spatial_scalable_extension++;
  924. #endif /* VERIFY */
  925.  
  926. }
  927.  
  928.  
  929. /* decode picture temporal scalable extension
  930.  *
  931.  * not implemented
  932.  */
  933. /* ISO/IEC 13818-2 section 6.2.3.4. */
  934. static void picture_temporal_scalable_extension()
  935. {
  936.   Error("temporal scalability not supported\n");
  937.  
  938. #ifdef VERIFY
  939.   verify_picture_temporal_scalable_extension++;
  940. #endif /* VERIFY */
  941. }
  942.  
  943.  
  944. /* decode extra bit information */
  945. /* ISO/IEC 13818-2 section 6.2.3.4. */
  946. static int extra_bit_information()
  947. {
  948.   int Byte_Count = 0;
  949.  
  950.   while (Get_Bits1())
  951.   {
  952.     Flush_Buffer(8);
  953.     Byte_Count++;
  954.   }
  955.  
  956.   return(Byte_Count);
  957. }
  958.  
  959.  
  960.  
  961. /* ISO/IEC 13818-2 section 5.3 */
  962. /* Purpose: this function is mainly designed to aid in bitstream conformance
  963.    testing.  A simple Flush_Buffer(1) would do */
  964. #ifdef STORM
  965. void marker_bit(char *text)
  966. #else
  967. void marker_bit(text)
  968. char *text;
  969. #endif
  970. {
  971.   int marker;
  972.  
  973.   marker = Get_Bits(1);
  974.  
  975. #ifdef VERIFY  
  976.   if(!marker)
  977.     printf("ERROR: %s--marker_bit set to 0",text);
  978. #endif
  979. }
  980.  
  981.  
  982. /* ISO/IEC 13818-2  sections 6.3.4.1 and 6.2.2.2.2 */
  983. static void user_data()
  984. {
  985.   /* skip ahead to the next start code */
  986.   next_start_code();
  987. }
  988.  
  989.  
  990.  
  991. /* Copyright extension */
  992. /* ISO/IEC 13818-2 section 6.2.3.6. */
  993. /* (header added in November, 1994 to the IS document) */
  994.  
  995.  
  996. static void copyright_extension()
  997. {
  998.   int pos;
  999.   int reserved_data;
  1000.  
  1001.   pos = ld->Bitcnt;
  1002.   
  1003.  
  1004.   copyright_flag =       Get_Bits(1); 
  1005.   copyright_identifier = Get_Bits(8);
  1006.   original_or_copy =     Get_Bits(1);
  1007.   
  1008.   /* reserved */
  1009.   reserved_data = Get_Bits(7);
  1010.  
  1011.   marker_bit("copyright_extension(), first marker bit");
  1012.   copyright_number_1 =   Get_Bits(20);
  1013.   marker_bit("copyright_extension(), second marker bit");
  1014.   copyright_number_2 =   Get_Bits(22);
  1015.   marker_bit("copyright_extension(), third marker bit");
  1016.   copyright_number_3 =   Get_Bits(22);
  1017.  
  1018.   if(Verbose_Flag>NO_LAYER)
  1019.   {
  1020.     printf("copyright_extension (byte %d)\n",(pos>>3)-4);
  1021.     if (Verbose_Flag>SEQUENCE_LAYER)
  1022.     {
  1023.       printf("  copyright_flag =%d\n",copyright_flag);
  1024.         
  1025.       printf("  copyright_identifier=%d\n",copyright_identifier);
  1026.         
  1027.       printf("  original_or_copy = %d (original=1, copy=0)\n",
  1028.         original_or_copy);
  1029.         
  1030.       printf("  copyright_number_1=%d\n",copyright_number_1);
  1031.       printf("  copyright_number_2=%d\n",copyright_number_2);
  1032.       printf("  copyright_number_3=%d\n",copyright_number_3);
  1033.     }
  1034.   }
  1035.  
  1036. #ifdef VERIFY
  1037.   verify_copyright_extension++;
  1038. #endif /* VERIFY */
  1039. }
  1040.  
  1041.  
  1042.  
  1043. /* introduced in September 1995 to assist Spatial Scalability */
  1044. static void Update_Temporal_Reference_Tacking_Data()
  1045. {
  1046.   static int temporal_reference_wrap  = 0;
  1047.   static int temporal_reference_old   = 0;
  1048.  
  1049.   if (ld == &base)          /* *CH* */
  1050.   {
  1051.     if (picture_coding_type!=B_TYPE && temporal_reference!=temporal_reference_old)  
  1052.     /* check first field of */
  1053.     {                           
  1054.        /* non-B-frame */
  1055.       if (temporal_reference_wrap)      
  1056.       {/* wrap occured at previous I- or P-frame */ 
  1057.        /* now all intervening B-frames which could 
  1058.           still have high temporal_reference values are done  */
  1059.         Temporal_Reference_Base += 1024;
  1060.         temporal_reference_wrap = 0;
  1061.       }
  1062.       
  1063.       /* distinguish from a reset */
  1064.       if (temporal_reference<temporal_reference_old && !Temporal_Reference_GOP_Reset)   
  1065.         temporal_reference_wrap = 1;  /* we must have just passed a GOP-Header! */
  1066.       
  1067.       temporal_reference_old = temporal_reference;
  1068.       Temporal_Reference_GOP_Reset = 0;
  1069.     }
  1070.  
  1071.     True_Framenum = Temporal_Reference_Base + temporal_reference;
  1072.     
  1073.     /* temporary wrap of TR at 1024 for M frames */
  1074.     if (temporal_reference_wrap && temporal_reference <= temporal_reference_old)    
  1075.       True_Framenum += 1024;                
  1076.  
  1077.     True_Framenum_max = (True_Framenum > True_Framenum_max) ?
  1078.                         True_Framenum : True_Framenum_max;
  1079.   }
  1080. }
  1081.